home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / iadd.c next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  11.4 KB  |  428 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  iadd.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*      iadd.c          RD, 23.12.89    */
  17.  
  18. #include <LEDA/impl/iint.h>
  19. #include <LEDA/impl/iloc.h>
  20.  
  21. void IplasI(a, b)
  22.         register pInteger a;
  23.     register const Integer *b;
  24. /* a+=b; */
  25. {   if (a->sign==b->sign) {
  26.         register int neededlength=a->length;
  27.         if (neededlength<b->length) {
  28.                 neededlength=b->length;
  29.         }
  30.         neededlength++;
  31.         if (neededlength>a->maxlength) {
  32.             register pPLACE newv;
  33.         register int oldlength=a->maxlength;
  34.             a->maxlength=neededlength;
  35.             newv=newvec(&a->maxlength);
  36.             a->length=cvadd(newv, a->vec, b->vec, a->length, b->length);
  37.             delvec(a->vec, oldlength);
  38.             a->vec=newv;
  39.             return;
  40.         } else {
  41.         a->length=cvadd(a->vec, a->vec, b->vec, a->length, b->length);
  42.             return;
  43.         }
  44.     } else {
  45.         /* Vorzeichen verschieden, subtrahiere betragsmaessig 
  46.                 kleineres von groesserem */
  47.         if ((b->length>a->length)||((b->length==a->length)
  48.                         &&vecgt(b->vec, a->vec, a->length))) {
  49.             /* |b|>|a| */
  50.             register int neededlength=b->length;
  51.             if (neededlength<=a->maxlength) {
  52.         a->length=cvsub(a->vec, b->vec, a->vec, 
  53.                 b->length, a->length);
  54.                 a->sign=b->sign;
  55.                 return;
  56.             } else {
  57.                 register pPLACE newv;
  58.                 register int oldlength=a->maxlength;
  59.                 a->maxlength=neededlength;
  60.                 newv=newvec(&a->maxlength);
  61.                 a->length=cvsub(newv, b->vec, a->vec, 
  62.                 b->length, a->length);
  63.                 delvec(a->vec, oldlength);
  64.                 a->vec=newv;
  65.                 a->sign=b->sign;
  66.                 return;
  67.             }
  68.         } else {
  69.                 /* |b| <= |a| */
  70.         register int l=a->length;
  71.         register PLACE * lp=&(a->vec[l-1]);
  72.                 cvecsubto(a->vec, b->vec, b->length);
  73.         while ((l>0)&&(! *lp)) {
  74.             l--; lp--;
  75.         }
  76.         a->length=l;
  77.                 if (!l)
  78.                         a->sign = PLUS;
  79.                 return;
  80. }   }   }       /* IplasI */
  81.  
  82. void IasIplI(sum, a, b)
  83.         register pInteger sum;
  84.     register const Integer *a, *b;
  85. /* sum=a+b; */
  86. {   register int neededlength;
  87.     if (sum==a) {
  88.         IplasI(sum, b);
  89.     return;
  90.     }
  91.     if (sum==b) {
  92.         IplasI(sum, a);
  93.     return;
  94.     }
  95.     if (a->sign==b->sign) {     /* Addition */
  96.         neededlength=a->length;
  97.         if (neededlength<b->length)
  98.             neededlength=b->length;
  99.         neededlength++;
  100.         if (neededlength>sum->maxlength) {
  101.             delvec(sum->vec, sum->maxlength);
  102.             sum->maxlength=neededlength;
  103.             sum->vec=newvec(&sum->maxlength);
  104.         }
  105.         sum->length=cvadd(sum->vec, a->vec, b->vec, a->length, b->length);
  106.         sum->sign=a->sign;
  107.         return;
  108.     } else {            /* Subtraktion */
  109.         neededlength=a->length;
  110.         if (neededlength<b->length)
  111.             neededlength=b->length;
  112.         if (neededlength>sum->maxlength) {      
  113.             delvec(sum->vec, sum->maxlength);
  114.             sum->maxlength=neededlength;
  115.             sum->vec=newvec(&sum->maxlength);
  116.         }
  117.         if ((b->length>a->length) || (b->length==a->length)
  118.                 && vecgt(b->vec, a->vec, a->length)) {
  119.             /* |b| > |a| */
  120.             sum->length=cvsub(sum->vec, b->vec, a->vec, 
  121.                 b->length, a->length);
  122.             sum->sign=b->sign;
  123.         return;
  124.         } else {
  125.             /*  |b| <= |a| */
  126.             sum->length=cvsub(sum->vec, a->vec, b->vec, 
  127.                 a->length, b->length);
  128.         if (!sum->length)
  129.         sum->sign=PLUS;
  130.         else
  131.                 sum->sign=a->sign;
  132.         return;
  133.         }
  134. }   }           /* IasIplI */
  135.  
  136. void ImiasI(a, b)
  137.         register pInteger a;
  138.     register const Integer *b;
  139. /* a-=b; */
  140. {   if (a->sign!=b->sign) {
  141.         register int neededlength=a->length;
  142.         if (neededlength<b->length) {
  143.                 neededlength=b->length;
  144.         }
  145.         neededlength++;
  146.         if (neededlength>a->maxlength) {
  147.             register pPLACE newv;
  148.             register int oldlength=a->maxlength;
  149.             a->maxlength=neededlength;
  150.             newv=newvec(&a->maxlength);
  151.             a->length=cvadd(newv, a->vec, b->vec, a->length, b->length);
  152.             delvec(a->vec, oldlength);
  153.             a->vec=newv;
  154.             return;
  155.         } else {
  156.             a->length=cvadd(a->vec, a->vec, b->vec, a->length, b->length);
  157.             return;
  158.         }
  159.     } else {
  160.         /* Vorzeichen gleich, subtrahiere betragsmaessig 
  161.                 kleineres von groesserem */
  162.         if ((b->length>a->length)||((b->length==a->length)
  163.                         &&vecgt(b->vec, a->vec, a->length))) {
  164.             /* |b|>|a| */
  165.             register int neededlength=b->length;
  166.             if (neededlength<=a->maxlength) {
  167.         a->length=cvsub(a->vec, b->vec, a->vec, 
  168.                 b->length, a->length);
  169.                 a->sign^=MINUS;
  170.                 return;
  171.             } else {
  172.                 register pPLACE newv;
  173.                 register int oldlength=a->maxlength;
  174.                 a->maxlength=neededlength;
  175.                 newv=newvec(&a->maxlength);
  176.                 a->length=cvsub(newv, b->vec, a->vec, 
  177.                 b->length, a->length);
  178.                 delvec(a->vec, oldlength);
  179.                 a->vec=newv;
  180.                 a->sign^=MINUS;
  181.                 return;
  182.             }
  183.         } else {
  184.                 /* |b| <= |a| */
  185.         register int l=a->length;
  186.         register PLACE * lp=&(a->vec[l-1]);
  187.                 cvecsubto(a->vec, b->vec, b->length);
  188.         while ((l>0)&&(! *lp)) {
  189.             l--; lp--;
  190.         }
  191.         a->length=l;
  192.                 if (!l)
  193.                         a->sign = PLUS;
  194.                 return;
  195. }   }   }       /* ImiasI */
  196.  
  197. void IasImiI(diff, a, b)
  198.         register pInteger diff;
  199.     register const Integer *a, *b;
  200. /* diff=a-b; */
  201. {   register int neededlength;
  202.     if (diff==a) {
  203.         ImiasI(diff, b);
  204.     return;
  205.     }
  206.     if (diff==b) {
  207.         ImiasI(diff, a);
  208.     return;
  209.     }
  210.     if (a->sign!=b->sign) {     /* Addition */
  211.         neededlength=a->length;
  212.         if (neededlength<b->length)
  213.             neededlength=b->length;
  214.         neededlength++;
  215.         if (neededlength>diff->maxlength) {
  216.             delvec(diff->vec, diff->maxlength);
  217.             diff->maxlength=neededlength;
  218.             diff->vec=newvec(&diff->maxlength);
  219.         }
  220.         diff->length=cvadd(diff->vec, a->vec, b->vec, a->length, b->length);
  221.         diff->sign=a->sign;
  222.         return;
  223.     } else {            /* Subtraktion */
  224.         neededlength=a->length;
  225.         if (neededlength<b->length)
  226.             neededlength=b->length;
  227.         if (neededlength>diff->maxlength) {      
  228.             delvec(diff->vec, diff->maxlength);
  229.             diff->maxlength=neededlength;
  230.             diff->vec=newvec(&diff->maxlength);
  231.         }
  232.         if ((b->length>a->length) || (b->length==a->length)
  233.                 && vecgt(b->vec, a->vec, a->length)) {
  234.             /*  |b| > |a| */
  235.             diff->length=cvsub(diff->vec, b->vec, a->vec, 
  236.                 b->length, a->length);
  237.             diff->sign=a->sign^MINUS;
  238.         return;
  239.         } else {
  240.             /*  |b| <= |a| */
  241.             diff->length=cvsub(diff->vec, a->vec, b->vec, 
  242.                 a->length, b->length);
  243.         if (!diff->length)
  244.         diff->sign=PLUS;
  245.         else
  246.                 diff->sign=a->sign;
  247.         return;
  248.         }
  249. }   }           /* IasImiI */
  250.  
  251. void Iinc(a)
  252.         register Integer *a;
  253. /* a++; */
  254. {   if (a->sign==PLUS) {
  255.         register int neededlength=a->length+1;
  256.     PLACE b=1;
  257.         if (neededlength>a->maxlength) {
  258.             register pPLACE newv;
  259.         register int oldlength=a->maxlength;
  260.             a->maxlength=neededlength;
  261.             newv=newvec(&a->maxlength);
  262.             a->length=cvadd(newv, a->vec, &b, a->length, 1);
  263.             delvec(a->vec, oldlength);
  264.             a->vec=newv;
  265.             return;
  266.         } else {
  267.         a->length=cvadd(a->vec, a->vec, &b, a->length, 1);
  268.             return;
  269.         }
  270.     } else {
  271.         /* Subtrahiere 1 von |a| */
  272.     register int l=a->length;
  273.     register PLACE * lp=&(a->vec[l-1]);
  274.     PLACE b=1;
  275.     cvecsubto(a->vec, &b, 1);
  276.     while ((l>0)&&(! *lp)) {
  277.         l--; lp--;
  278.     }
  279.     a->length=l;
  280.     if (!l)
  281.         a->sign = PLUS;
  282.     return;
  283. }   }           /* Iinc */
  284.  
  285. void Idec(a)
  286.         register Integer *a;
  287. /* a--; */
  288. {   if (a->sign==MINUS) {
  289.         register int neededlength=a->length+1;
  290.     PLACE b=1;
  291.         if (neededlength>a->maxlength) {
  292.             register pPLACE newv;
  293.         register int oldlength=a->maxlength;
  294.             a->maxlength=neededlength;
  295.             newv=newvec(&a->maxlength);
  296.             a->length=cvadd(newv, a->vec, &b, a->length, 1);
  297.             delvec(a->vec, oldlength);
  298.             a->vec=newv;
  299.             return;
  300.         } else {
  301.         a->length=cvadd(a->vec, a->vec, &b, a->length, 1);
  302.             return;
  303.     }   }
  304.     if (!a->length) {
  305.     a->sign=MINUS;
  306.     a->length=1;
  307.     a->vec[0]=1;
  308.     return;
  309.     } else {
  310.         /* Subtrahiere 1 von |a| */
  311.     register int l=a->length;
  312.     register PLACE * lp=&(a->vec[l-1]);
  313.     PLACE b=1;
  314.     cvecsubto(a->vec, &b, 1);
  315.     while ((l>0)&&(! *lp)) {
  316.         l--; lp--;
  317.     }
  318.     a->length=l;
  319.     return;
  320. }   }           /* Idec */
  321.  
  322.  
  323. BOOLEAN IeqI(a, b)
  324. /* return a==b; */
  325.         register const Integer *a, *b;
  326. {       if ((a->sign==b->sign)&&(a->length==b->length)&&
  327.                 veceq(a->vec, b->vec, a->length))
  328.                 return TRUE;
  329.         else
  330.                 return FALSE;
  331. }
  332.  
  333. BOOLEAN IgtI(a, b)
  334. /* return a>b; */
  335.         register const Integer *a, *b;
  336. {       if (a->sign==PLUS) {
  337.                 if (b->sign==MINUS)
  338.                         return TRUE;
  339.                 else {
  340.                         if ((a->length>b->length)||((a->length==b->length)
  341.                                         &&vecgt(a->vec, b->vec, a->length)))
  342.                                 return TRUE;
  343.                         else
  344.                                 return FALSE;
  345.                 }
  346.         } else {
  347.                 if (b->sign==PLUS)
  348.                         return FALSE;
  349.                 else {
  350.                         if ((a->length>b->length)||((a->length==b->length)
  351.                                     &&!vecgt(b->vec, a->vec, a->length)))
  352.                                 return FALSE;
  353.                         else
  354.                                 return TRUE;
  355. }       }       }       /* IgtI */
  356.  
  357. void Ineg(a)
  358.     register pInteger a;
  359. {    if (a->length)
  360.         a->sign^=MINUS;
  361. }
  362.  
  363. BOOLEAN IneI(a, b)
  364. /* return a!=b; */
  365.         const Integer *a, *b;
  366. {       return !IeqI(a, b);
  367. }
  368.  
  369. BOOLEAN IgeI(a, b)
  370. /* return a>=b; */
  371.         const Integer *a, *b;
  372. {       return !IgtI(b, a);
  373. }
  374.  
  375. BOOLEAN IltI(a, b)
  376. /* return a<b; */
  377.         const Integer *a, *b;
  378. {       return IgtI(b, a);
  379. }
  380.  
  381. BOOLEAN IleI(a, b)
  382. /* return a<=b; */
  383.         const Integer *a, *b;
  384. {       return !IgtI(a, b);
  385. }
  386.  
  387. BOOLEAN Ige0(a)
  388.     const Integer *a;
  389. {    return (a->sign==PLUS);
  390. }
  391.  
  392. BOOLEAN Igt0(a)
  393.     const Integer *a;
  394. {    return ((a->sign==PLUS)&&(a->length));
  395. }
  396.  
  397. BOOLEAN Ile0(a)
  398.     const Integer *a;
  399. {    return (!a->length || (a->sign==MINUS));
  400. }
  401.  
  402. BOOLEAN Ilt0(a)
  403.     const Integer *a;
  404. {    return (a->sign==MINUS);
  405. }
  406.  
  407. BOOLEAN Ieq0(a)
  408.     const Integer *a;
  409. {    return (!a->length);
  410. }
  411.  
  412. BOOLEAN Ieq1(a)
  413.     const Integer *a;
  414. {    if ((*(a->vec)==1)&&(a->length==1)&&(a->sign==PLUS))
  415.         return TRUE;
  416.     else
  417.         return FALSE;
  418. }
  419.  
  420. int sign(a)
  421.     const Integer *a;
  422. {    if (!a->length) { return 0; }
  423.         else {
  424.           if (a->sign==PLUS) { return 1; }
  425.           else { return -1; }
  426.         }
  427. }
  428.